import { gameConfigHandle } from "core/config/gameConfig"
import Random from "core/utils/random"
import utils from "core/utils/utils"
import { AttriItemModel, EquipmentItemModel, ItemModel } from "core/model/itemModel"
import { PlayerModel } from "core/model/playerModel"
import itemHandle from "./itemHandle"
import bagHandle from "./bagHandle"
import partnerHandle from "./partnerHandle"
import { AttriType, EquipmentType, OccType } from "core/typeDefine/typeDefine"
import adventureHandle from "./adventureHandle"
import gameUtils from "core/utils/gameUtils"
import playerHandle from "./playerHandle"

class EquipmentHandle {
    create(player: PlayerModel, type: string, rand: Random, { equipmentLvl, lucky, quality, minQuality, maxQuality, equipmentType, equipemntItemID, mainAttris, subAttris }:
        { equipmentLvl?: number, lucky?: number, quality?: number, minQuality?: number, maxQuality?: number, equipmentType?: EquipmentType, equipemntItemID?: number, mainAttris?: AttriItemModel[], subAttris?: AttriItemModel[] }) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment

        if (utils.isNull(type)) {
            type = 'normal'
        }
        //套装
        let packageAttributesId = 0
        // let rate = equipmentConfig.packageAttributesRate[type]
        // if (rand.intn(1000) <= rate) {
        //     packageAttributesId = utils.getOneFromArray(equipmentConfig.packageAttributesList, rand)
        // }

        if (utils.isNull(equipmentType)) {
            equipmentType = utils.getOneFromArray(equipmentConfig.equipmentListType, rand)
        }
        if (utils.isNull(equipmentLvl)) {
            let { total, maxTotal } = adventureHandle.getAdventureMapProgress(player)
            equipmentLvl = equipmentHandle.getEquipmentLvl(maxTotal)
        }

        if (utils.isNull(quality)) {
            quality = utils.getQualityByodds(lucky || 0, minQuality || 0, maxQuality || equipmentConfig.equimentMaxQuality, gameConfigHandle.gameConfig.equipment.equipmentQualityOdds, rand)
        }
        if (utils.isNull(equipemntItemID)) {
            equipemntItemID = utils.getOneFromArray(equipmentConfig.createEquipmentList[equipmentType], rand)
        }
        let equipmentItemConfig = gameConfigHandle.configByID[equipemntItemID]

        let equipmentAttriPer = equipmentConfig.equipmentMainAttriPer
        if (!mainAttris) {
            mainAttris = []
            let mainAttriNames: any[] = utils.getRandomArrayNoRepeat(equipmentItemConfig.mainAttri, 1, rand)
            let attriLvlupConfig = gameConfigHandle.gameConfig.attriLvlup
            mainAttriNames.forEach((mainAttriName) => {
                let { max, min } = this.getMainValueRange(mainAttriName, equipmentLvl, quality)
                let mainAttriValue = utils.addRandomByPer(max, equipmentAttriPer, 100, rand, attriLvlupConfig.attriValuesList[mainAttriName][4] || 0)
                let attriItem = new AttriItemModel()
                attriItem.name = mainAttriName
                attriItem.value = mainAttriValue
                mainAttris.push(attriItem)
            })
        }

        if (!subAttris) {
            subAttris = this.createSubAttris(quality, equipmentLvl, equipmentType, rand)
        }

        let equipment = new EquipmentItemModel({
            lvl: equipmentLvl,
            quality: quality,
            mainAttris: mainAttris,
            subAttris: subAttris,
            packageAttributesId
        })
        let item = itemHandle.create({ tid: equipemntItemID })
        item.equipment = equipment
        this.calcPower(player, item)
        return item
    }


    //随机属性生成
    createSubAttris(quality: number, equipmentLvl: number, equipmentType: EquipmentType, rand: Random) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let subAttriInfoConfig = equipmentConfig.subAttriInfo
        let randAttriAmount = subAttriInfoConfig.randAttriAmountByQality[quality]
        let spAttriAmount = subAttriInfoConfig.spAttriAmountByqQality[quality]
        let subAttris: AttriItemModel[] = []
        let equipmentAttriPer = equipmentConfig.equipmentSubAttriPer

        let spAttriTypes = {
            [AttriType.Attri]: randAttriAmount - spAttriAmount,
            [AttriType.SpAttri]: 0,
            [AttriType.StatusHurtPer]: 0,
            [AttriType.StatusReduceHurt]: 0,
            [AttriType.DecSkillCd]: 0,
            [AttriType.SkillHurtPer]: 0,
        }
        let spAttriTypeArray: any = utils.getRandomArrayNoRepeat(subAttriInfoConfig.spAttriList, spAttriAmount, rand)

        spAttriTypeArray.forEach(spAttriType => {
            spAttriTypes[spAttriType] += 1
        })
        if (spAttriTypes[AttriType.Attri] > 0) { //属性
            let subattriNames: any = utils.getRandomArrayNoRepeat(subAttriInfoConfig.randAttriByPart[equipmentType], spAttriTypes[AttriType.Attri], rand)
            subattriNames.forEach(subattriName => {
                let { max, min } = this.getSubValueRange(subattriName, equipmentLvl, quality, AttriType.Attri)
                let value = Math.floor(utils.addRandomByPer(max, equipmentAttriPer, 100, rand))
                let attriItem = new AttriItemModel()
                attriItem.type = AttriType.Attri
                attriItem.name = subattriName
                attriItem.value = value
                subAttris.push(attriItem)
            })
        }
        if (spAttriTypes[AttriType.StatusHurtPer] > 0) { //buff状态伤害属性
            let buffTypes: any = utils.getRandomArrayNoRepeat(subAttriInfoConfig.statusHurtList[equipmentType], spAttriTypes[AttriType.StatusHurtPer], rand)
            buffTypes.forEach(buffType => {
                let { max, min } = this.getSubValueRange(buffType, equipmentLvl, quality, AttriType.StatusHurtPer)
                let value = utils.addRandomByPer(max, equipmentAttriPer, 100, rand, subAttriInfoConfig.statusHurtPer.qualityValues[4] || 0)
                let attriItem = new AttriItemModel()
                attriItem.type = AttriType.StatusHurtPer
                attriItem.name = buffType
                attriItem.value = value
                subAttris.push(attriItem)
            })
        }
        if (spAttriTypes[AttriType.StatusReduceHurt] > 0) { //buff状态减伤属性
            let buffTypes: any = utils.getRandomArrayNoRepeat(subAttriInfoConfig.statusReduceList[equipmentType], spAttriTypes[AttriType.StatusReduceHurt], rand)
            buffTypes.forEach(buffType => {
                let { max, min } = this.getSubValueRange(buffType, equipmentLvl, quality, AttriType.StatusReduceHurt)
                let value = utils.addRandomByPer(max, equipmentAttriPer, 100, rand, subAttriInfoConfig.statusReduceHurtPer.qualityValues[4] || 0)
                let attriItem = new AttriItemModel()
                attriItem.type = AttriType.StatusReduceHurt
                attriItem.name = buffType
                attriItem.value = value
                subAttris.push(attriItem)
            })
        }
        if (spAttriTypes[AttriType.DecSkillCd] > 0) { //降低技能cd属性
            let skillIds: any = utils.getRandomArrayNoRepeat(subAttriInfoConfig.reduceSkillCdList[equipmentType], spAttriTypes[AttriType.DecSkillCd], rand)
            skillIds.forEach(skillId => {
                let { max, min } = this.getSubValueRange(skillId, equipmentLvl, quality, AttriType.DecSkillCd)
                let value = utils.addRandomByPer(max, equipmentAttriPer, 100, rand, subAttriInfoConfig.reduceSkillCd.qualityValues[4] || 0)
                let attriItem = new AttriItemModel()
                attriItem.type = AttriType.DecSkillCd
                attriItem.name = skillId
                attriItem.value = value
                subAttris.push(attriItem)
            })
        }
        if (spAttriTypes[AttriType.SkillHurtPer] > 0) { //技能伤害属性
            let skillIds: any = utils.getRandomArrayNoRepeat(subAttriInfoConfig.skillHurtPerList[equipmentType], spAttriTypes[AttriType.SkillHurtPer], rand)
            skillIds.forEach(skillId => {
                let { max, min } = this.getSubValueRange(skillId, equipmentLvl, quality, AttriType.SkillHurtPer)
                let value = utils.addRandomByPer(max, equipmentAttriPer, 100, rand, subAttriInfoConfig.addSkillHurtPer.qualityValues[4] || 0)
                let attriItem = new AttriItemModel()
                attriItem.type = AttriType.SkillHurtPer
                attriItem.name = skillId
                attriItem.value = value
                subAttris.push(attriItem)
            })
        }
        if (spAttriTypes[AttriType.SpAttri] > 0) { //特殊属性
            let spattriids: any = utils.getRandomArrayNoRepeat(subAttriInfoConfig.spAttriByPart[equipmentType], spAttriTypes[AttriType.SpAttri], rand)
            spattriids.forEach(spattriid => {
                let idConfig = subAttriInfoConfig.spAttrisList[spattriid]
                let attriName = idConfig.attriName
                let { max, min } = this.getSubValueRange(attriName, equipmentLvl, quality, AttriType.SpAttri)
                let value = utils.addRandomByPer(max, equipmentAttriPer, 100, rand, idConfig.qualityValues[4] || 0)
                let attriItem = new AttriItemModel()
                attriItem.type = AttriType.SpAttri
                attriItem.name = attriName
                attriItem.value = value
                subAttris.push(attriItem)
            })
        }
        subAttris.sort(() => { return rand.intn(100) > 50 ? 1 : -1 })
        return subAttris
    }

    //套装数量
    getPackageAttributesActiveAmount = (player: PlayerModel, occType: OccType, packageAttributesId: number, planIndex?: number, isRefresh?: boolean) => {
        let equipments = player.teamEquipment.equipmentList[occType][0]
        if (!packageAttributesId) {
            return 0
        }
        if (planIndex == null || planIndex == undefined) {
            planIndex = player.teamEquipment.packageActive[occType]
        }
        if (isRefresh == null || isRefresh == undefined) {
            isRefresh = false
        }
        let packages = player.teamEquipment.packageList[occType][planIndex]
        let amount = 0
        gameConfigHandle.gameConfig.equipment.equipmentListType.forEach(type => {
            if (packageAttributesId == packages[type].id && (isRefresh || equipments[type])) {
                amount++
            }
        })
        return amount
    }

    //计算套装收益加成
    calcEquipmentAddGoldPer(player: PlayerModel) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let packageActiveAmount = equipmentConfig.packageAttributesActive
        player.adventure.addGoldPer = 0
        player.adventure.addEquipmentDropPer = 0
        for (let i = 0; i < player.team.teamList.length; i++) {
            let tid = player.team.teamList[i]
            if (tid) {
                let occType = gameConfigHandle.configByID[tid].occType
                equipmentConfig.packageAttributesList.forEach(id => {
                    let amount = this.getPackageAttributesActiveAmount(player, occType, id)
                    gameConfigHandle.configByID[id].attris.forEach((attri, i) => {
                        if (amount >= packageActiveAmount[i]) {
                            let lvl = player.packageAttributesLvls[id] || 1
                            if (i == 0 && lvl < 10) {
                                lvl = 10
                            }
                            if (attri.attriType == AttriType.Adventure) {
                                let attriName = attri.attriName
                                let attriValues: any = gameConfigHandle.gameConfig.attriLvlup.packageAttributesAttriValues[i]
                                let value = partnerHandle.getAttriValues(attriName, lvl, attriValues) * attri.up
                                if (attriName == 'addGoldPer') {
                                    player.adventure.addGoldPer += value
                                } else if (attriName == 'addEquipmentDropPer') {
                                    player.adventure.addEquipmentDropPer += value
                                }
                            }
                        }
                    })
                })
            }
        }
        // console.log('addGoldPer', player.adventure.addGoldPer, 'addEquipmentDropPer', player.adventure.addEquipmentDropPer)
    }

    //计算职业的套装属性加成
    calcPackageEquipmentAttris(player: PlayerModel, occType: OccType) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let packageActiveAmount = equipmentConfig.packageAttributesActive
        let equipmentAttris = {}, adventureAttris = {}, attris = {}, skill: number = null
        equipmentConfig.packageAttributesList.forEach(id => {
            let amount = this.getPackageAttributesActiveAmount(player, occType, id)
            gameConfigHandle.configByID[id].attris.forEach((attri, i) => {
                if (amount >= packageActiveAmount[i]) {
                    let lvl = player.packageAttributesLvls[id] || 1
                    if (i == 0 && lvl < 10) {
                        lvl = 10
                    }
                    let attriName = attri.attriName
                    let attriValues: any = gameConfigHandle.gameConfig.attriLvlup.packageAttributesAttriValues[i]
                    let value = 0
                    if (attriName) {
                        value = partnerHandle.getAttriValues(attriName, lvl, attriValues) * (attri.up || 1)
                    }
                    if (attri.attriType == AttriType.EquipmentAttri) {
                        if (!equipmentAttris[attriName]) {
                            equipmentAttris[attriName] = 0
                        }
                        equipmentAttris[attriName] += value
                    } else if (attri.attriType == AttriType.OccAttri) {
                        if (occType == attri.occType) {
                            if (!attris[attriName]) {
                                attris[attriName] = 0
                            }
                            attris[attriName] += value
                        }
                    } else if (attri.attriType == AttriType.Skill) {
                        if (occType == attri.occType) {
                            let index = Math.floor(lvl / 7)
                            skill = attri.skills[index]
                        }
                    } else if (attri.attriType == AttriType.Attri) {
                        if (!attris[attriName]) {
                            attris[attriName] = 0
                        }
                        attris[attriName] += value
                    } else if (attri.attriType == AttriType.Adventure) {
                        if (!adventureAttris[attriName]) {
                            adventureAttris[attriName] = 0
                        }
                        adventureAttris[attriName] += value
                    }
                }
            })
        })
        return { equipmentAttris, adventureAttris, attris, skill }
    }

    getOccEquipmentsAttris(player: PlayerModel, occType: OccType) {
        let attris = {}
        let equipments = player.teamEquipment.equipmentList[occType][0]
        let equipmentAttris = this.calcPackageEquipmentAttris(player, occType).equipmentAttris
        gameConfigHandle.gameConfig.equipment.equipmentListType.forEach(type => {
            let item = equipments[type]
            if (item) {
                item.equipment.mainAttris.forEach(attriItem => {
                    let name = attriItem.name
                    let up = equipmentAttris['equipmentMainUpPer'] || 0
                    let value = attriItem.value * (1 + up / 100)
                    if (!attris[name]) {
                        attris[name] = 0
                    }
                    attris[name] += value
                })
                item.equipment.subAttris.forEach(attriItem => {
                    let type = attriItem.type
                    let name = attriItem.name
                    let up = equipmentAttris['equipmentSubUpPer'] || 0
                    let value = attriItem.value * (1 + up / 100)
                    if (type == AttriType.Attri || type == AttriType.SpAttri) {
                        if (!attris[name]) {
                            attris[name] = 0
                        }
                        attris[name] += value
                    }
                })
            }
        })
        return attris
    }

    getWashEquipmentSubAttriList(item: ItemModel, subAttriIndex: number) {
        let attriItem = item.equipment.subAttris[subAttriIndex]
        if (!attriItem) {
            return { attriList: [] }
        }
        let equipmentType = gameConfigHandle.configByID[item.tid].equipmentType
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let subAttriInfoConfig = equipmentConfig.subAttriInfo
        let equipmentAttriPer = equipmentConfig.equipmentSubAttriPer
        let spAttriTypes = {
            [AttriType.Attri]: [],
            [AttriType.SpAttri]: [],
            [AttriType.StatusHurtPer]: [],
            [AttriType.StatusReduceHurt]: [],
            [AttriType.DecSkillCd]: [],
            [AttriType.SkillHurtPer]: [],
        }
        let attriList: any[] = []
        if (attriItem.type == AttriType.Attri) {
            attriList = subAttriInfoConfig.randAttriByPart[equipmentType].slice(0)
        } else if (attriItem.type == AttriType.SpAttri) {
            attriList = subAttriInfoConfig.spAttriByPart[equipmentType].slice(0)
        } if (attriItem.type == AttriType.DecSkillCd) {
            attriList = subAttriInfoConfig.reduceSkillCdList[equipmentType].slice(0)
        } if (attriItem.type == AttriType.StatusHurtPer) {
            attriList = subAttriInfoConfig.statusHurtPer[equipmentType].slice(0)
        } if (attriItem.type == AttriType.StatusReduceHurt) {
            attriList = subAttriInfoConfig.statusReduceList[equipmentType].slice(0)
        } if (attriItem.type == AttriType.SkillHurtPer) {
            attriList = subAttriInfoConfig.skillHurtPerList[equipmentType].slice(0)
        }
        item.equipment.subAttris.forEach(subAttri => {
            if (attriItem.type == subAttri.type) {
                spAttriTypes[subAttri.type].push(subAttri.name)
                let index = attriList.findIndex(item => item == subAttri.name)
                if (index >= 0) {
                    attriList.splice(index, 1)
                }
            }
        })

        return { washAttriList: attriList, washAttriType: attriItem.type }
    }

    washEquipmentSubAttri(item: ItemModel, subAttriIndex: number, rand) {
        let attriItem = item.equipment.subAttris[subAttriIndex]
        let equipmentType = gameConfigHandle.configByID[item.tid].equipmentType
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let subAttriInfoConfig = equipmentConfig.subAttriInfo
        let equipmentAttriPer = equipmentConfig.equipmentSubAttriPer
        let { washAttriList } = this.getWashEquipmentSubAttriList(item, subAttriIndex)
        let washAttriName = utils.getOneFromArray(washAttriList, rand)
        let { max, min, valueFloat } = this.getSubValueRange(washAttriName, item.equipment.lvl, item.equipment.quality, attriItem.type)
        let value = utils.addRandomByPer(max, equipmentAttriPer, 100, rand, valueFloat)
        item.equipment.subAttris[subAttriIndex] = new AttriItemModel({
            type: attriItem.type,
            name: washAttriName,
            value: value,
        })
    }


    getMainValueRange(attriName, equipmentLvl, quality) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let attriLvlupConfig = gameConfigHandle.gameConfig.attriLvlup
        let qualityAdd = equipmentConfig.qualityAdd
        let partnerConfig = gameConfigHandle.gameConfig.partner
        let equipmentAttriPer = equipmentConfig.equipmentMainAttriPer
        let mainAttriValue = partnerHandle.getAttriValues(attriName, equipmentLvl, attriLvlupConfig.equipmentMainAttriCoe)
        mainAttriValue = (1 + qualityAdd * quality / 100) * mainAttriValue
        let max = utils.floor(mainAttriValue, attriLvlupConfig.attriValuesList[attriName][4] || 0)
        let min = utils.floor(mainAttriValue * equipmentAttriPer / 100, attriLvlupConfig.attriValuesList[attriName][4] || 0)
        return { min, max }
    }


    getSubValueRange(attriName, equipmentLvl, quality, equipmentAttriType: AttriType) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let attriLvlupConfig = gameConfigHandle.gameConfig.attriLvlup
        let equipmentAttriPer = equipmentConfig.equipmentSubAttriPer
        let subAttriInfoConfig = equipmentConfig.subAttriInfo
        if (equipmentAttriType == AttriType.Attri) {
            let value = partnerHandle.getAttriValues(attriName, equipmentLvl, attriLvlupConfig.equipmentSubAttriCoe)
            let max = utils.floor(value, attriLvlupConfig.attriValuesList[attriName][4] || 0)
            let min = utils.floor(value * equipmentAttriPer / 100, attriLvlupConfig.attriValuesList[attriName][4] || 0)
            return { min, max, valueFloat: attriLvlupConfig.attriValuesList[attriName][4] || 0 }
        } else if (equipmentAttriType == AttriType.SpAttri) {
            let attriConfig = subAttriInfoConfig.spAttrisList[attriName]
            let qualtiyValue = utils.getIncValues(attriConfig.qualityValues, quality)
            let max = utils.getIncValues(attriConfig.lvlValues, equipmentLvl) + qualtiyValue
            if (max > attriConfig.maxValue) {
                max = attriConfig.maxValue
            }
            max = utils.floor(max, attriConfig.qualityValues[4] || 0)
            let min = utils.floor(max * equipmentAttriPer / 100, attriConfig.qualityValues[4] || 0)
            return { min, max, valueFloat: attriConfig.qualityValues[4] || 0 }

        } else if (equipmentAttriType == AttriType.StatusHurtPer) {
            let qualtiyValue = utils.getIncValues(subAttriInfoConfig.statusHurtPer.qualityValues, quality)
            let max = utils.getIncValues(subAttriInfoConfig.statusHurtPer.lvlValues, equipmentLvl) + qualtiyValue
            if (max > subAttriInfoConfig.statusHurtPer.maxValue) {
                max = subAttriInfoConfig.statusHurtPer.maxValue
            }
            max = utils.floor(max, subAttriInfoConfig.statusHurtPer.qualityValues[4] || 0)
            let min = utils.floor(max * equipmentAttriPer / 100, subAttriInfoConfig.statusHurtPer.qualityValues[4] || 0)
            return { min, max, valueFloat: subAttriInfoConfig.statusHurtPer.qualityValues[4] || 0 }
        } else if (equipmentAttriType == AttriType.StatusReduceHurt) {
            let qualtiyValue = utils.getIncValues(subAttriInfoConfig.statusReduceHurtPer.qualityValues, quality)
            let max = utils.getIncValues(subAttriInfoConfig.statusReduceHurtPer.lvlValues, equipmentLvl) + qualtiyValue
            if (max > subAttriInfoConfig.statusReduceHurtPer.maxValue) {
                max = subAttriInfoConfig.statusReduceHurtPer.maxValue
            }
            max = utils.floor(max, subAttriInfoConfig.statusReduceHurtPer.qualityValues[4] || 0)
            let min = utils.floor(max * equipmentAttriPer / 100, subAttriInfoConfig.statusReduceHurtPer.qualityValues[4] || 0)
            return { min, max, valueFloat: subAttriInfoConfig.statusReduceHurtPer.qualityValues[4] || 0 }
        } else if (equipmentAttriType == AttriType.DecSkillCd) {
            let qualtiyValue = utils.getIncValues(subAttriInfoConfig.reduceSkillCd.qualityValues, quality)
            let max = utils.getIncValues(subAttriInfoConfig.reduceSkillCd.lvlValues, equipmentLvl) + qualtiyValue
            if (max > subAttriInfoConfig.reduceSkillCd.maxValue) {
                max = subAttriInfoConfig.reduceSkillCd.maxValue
            }
            max = utils.floor(max, subAttriInfoConfig.reduceSkillCd.qualityValues[4] || 0)
            let min = utils.floor(max * equipmentAttriPer / 100, subAttriInfoConfig.reduceSkillCd.qualityValues[4] || 0)
            return { min, max, valueFloat: subAttriInfoConfig.reduceSkillCd.qualityValues[4] || 0 }
        } else if (equipmentAttriType == AttriType.SkillHurtPer) {
            let qualtiyValue = utils.getIncValues(subAttriInfoConfig.addSkillHurtPer.qualityValues, quality)
            let max = utils.getIncValues(subAttriInfoConfig.addSkillHurtPer.lvlValues, equipmentLvl) + qualtiyValue
            if (max > subAttriInfoConfig.addSkillHurtPer.maxValue) {
                max = subAttriInfoConfig.addSkillHurtPer.maxValue
            }
            max = utils.floor(max, subAttriInfoConfig.addSkillHurtPer.qualityValues[4] || 0)
            let min = utils.floor(max * equipmentAttriPer / 100, subAttriInfoConfig.addSkillHurtPer.qualityValues[4] || 0)
            return { min, max, valueFloat: subAttriInfoConfig.addSkillHurtPer.qualityValues[4] || 0 }
        }

    }


    destroy(player: PlayerModel, item: ItemModel) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let getItem = {}
        equipmentConfig.destroy.forEach(e => {
            let name: any = e.itemID
            let values = e.amount
            let value = utils.getIncValues(values, item.equipment.quality)
            if (isNaN(name)) {
                player.itemInfo[name] += value
            } else {
                bagHandle.addItem(player.bag, Number(name), value)
            }
            getItem[name] = value
        })
        let needConfig = gameConfigHandle.gameConfig.need
        if (item.equipment.forceLvl > 0) {
            let res = gameUtils.getNeedResource(player, needConfig.forgeEquipment, item.equipment.quality, item.equipment.forceLvl)
            res.needNodes.forEach(node => {
                let name: any = node[0]
                let value = Math.ceil(node[1] * 0.85)
                if (isNaN(name)) {
                    player.itemInfo[name] += value
                } else {
                    bagHandle.addItem(player.bag, Number(name), value)
                }
                getItem[name] = (getItem[name] || 0) + value
            })
        }
        if (item.equipment.enchant > 0) {
            let res = gameUtils.getNeedResource(player, needConfig.enchantEquipment, item.equipment.quality, item.equipment.enchant)
            res.needNodes.forEach(node => {
                let name: any = node[0]
                let value = Math.ceil(node[1] * 0.85)
                if (isNaN(name)) {
                    player.itemInfo[name] += value
                } else {
                    bagHandle.addItem(player.bag, Number(name), value)
                }
                getItem[name] = (getItem[name] || 0) + value
            })
        }
        //套装碎片
        let packageId = item.equipment.packageAttributesId || 0
        if (packageId !== 0) {
            let getId = gameConfigHandle.configByID[packageId].destoryGet
            bagHandle.addItem(player.bag, getId, 1)
            getItem[getId] = (getItem[getId] || 0) + 1
        }

        return getItem
    }

    getAttriAmountByQality(quality, lists: any, rand: Random) {
        let amount1 = lists[quality]
        let amount2 = 0
        if (amount1 > 0) {
            amount2 = Math.floor(amount1 / 2)
            amount2 = utils.getRandomNumber(0, amount2, rand)
        }
        return [amount1 - amount2, amount2]
    }

    // getEquipmentLvl(floor) {
    //     return floor
    // }

    getEquipmentLvl(floor) {
        let equipmentConfig = gameConfigHandle.gameConfig.equipment
        let values = equipmentConfig.equipmentLvlByFloor

        let a = values[2] / 2
        let b = values[1] + values[2] / 2
        let c = values[0] - floor
        let data = utils.calculateQuadratic(a, b, c)
        let lvl = 1
        if (data) {
            lvl = Math.floor(data) + 2
        } else {
            lvl = Math.ceil(floor / 4)
        }
        if (lvl > equipmentConfig.equipmentMaxLvl) {
            lvl = equipmentConfig.equipmentMaxLvl
        }
        return lvl
    }
    calcPower(player: PlayerModel, item: ItemModel) {
        let power = 0
        let quipmentPower = gameConfigHandle.gameConfig.equipment.equipmentPower
        let equipmentPowerPer = gameConfigHandle.gameConfig.equipment.equipmentPowerPer
        let per = 0
        item.equipment.mainAttris.forEach(attriItem => {
            let name = attriItem.name
            let value = attriItem.value
            power += (quipmentPower[name] || 0) * value
            // power += e.value
        })
        item.equipment.subAttris.forEach(attriItem => {
            let type = attriItem.type
            let name = attriItem.name
            let value = attriItem.value
            if (type == AttriType.StatusHurtPer) {
                power += quipmentPower.statusHurtPer * value
            } else if (type == AttriType.StatusReduceHurt) {
                power += quipmentPower.statusReduceHurt * value
            } else if (type == AttriType.DecSkillCd) {
                power += quipmentPower.decSkillCd * value
            } else if (type == AttriType.SkillHurtPer) {
                power += quipmentPower.addSkillHurtPer * value
            } else if (type == AttriType.Attri) {
                power += (quipmentPower[name] || 0) * value
            }
            if (equipmentPowerPer[name]) {
                per += value * equipmentPowerPer[name]
            }
        })
        power = Math.floor(power * (1 + per / 100))
        item.equipment.power = power
        return power
    }
}

let equipmentHandle = new EquipmentHandle()
export default equipmentHandle